home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / mac_file / vendor_d / neuralwa / nw2v50 / artio.c < prev    next >
Text File  |  1993-08-23  |  42KB  |  1,323 lines
  1. /* artio.c - character recognition user I/O function
  2.  
  3. /************************************************************************
  4.  * Copyright(C) 1987-1992 NeuralWare Inc                                *
  5.  * Penn Center West, IV-227, Pittsburgh, PA 15276                       *
  6.  * Telephone: (412) 787-8222    FAX: (412) 787-8220                     *
  7.  *                                                                      *
  8.  * All rights reserved.  No part of this program may be reproduced,     *
  9.  * stored in a retrieval system, or transmitted, in any form or by any  *
  10.  * means, electronic, mechanical, photocopying, recording or otherwise  *
  11.  * without the prior written permission of the copyright owner,         *
  12.  * NeuralWare, Inc.                                                     *
  13.  *                                                                      *
  14.  *                          PROPRIETARY NOTICE                          *
  15.  *                                                                      *
  16.  * This document is the property of NeuralWare, Inc. and contains       *
  17.  * trade-secrets and other proprietary information.  The information    *
  18.  * herein is reserved as proprietary to NeuralWare, and is not to be    *
  19.  * published, reproduced, copied, disclosed, used, or reverse           *
  20.  * engineered without the express written consent of a duly authorized  *
  21.  * representative of NeuralWare.                                        *
  22.  ************************************************************************
  23.  */
  24.  
  25. #ifndef SKY
  26. #include <string.h>
  27. #endif
  28.  
  29. #define UIO_SERVER             1
  30. #define SERVER_EMULATOR_FILE   1
  31. #define SKIP_COMPAT_DATA       1
  32. #include "userutl.h"
  33. #include "uio_strc.h"
  34. #include "uio_tran.h"
  35. #include "uio_reqs.pro"
  36. #include "uio_cmds.pro"
  37.  
  38. #ifndef SUN
  39. #ifndef DLC
  40. #include <stdlib.h>
  41. #endif
  42. #endif
  43.  
  44. #ifdef MAC
  45. #include "macuio.redef"
  46. #endif
  47.  
  48. /************************************************************************
  49.  *                                                                      *
  50.  *      Character Recognition User I/O Routine                          *
  51.  *                                                                      *
  52.  *      Options:                                                        *
  53.  *                                                                      *
  54.  *      ATTENTION I/O:  This allows the user to create a file of        *
  55.  *                      character patterns and their associated         *
  56.  *                      ASCII code. This file is written in .nna        *
  57.  *                      format and can be used either for File I/O      *
  58.  *                      or for User I/O learning. The user              *
  59.  *                      is prompted for file name (.nna extension       *
  60.  *                      assumed), and is given the option of writing or *
  61.  *                      appending the file. The user is provided with   *
  62.  *                      a grid in which to draw patterns. On entering   *
  63.  *                      a pattern, the user is prompted to enter, from  *
  64.  *                      the keyboard, the character that the pattern    *
  65.  *                      depicts. The file is closed on quitting.        *
  66.  *                                                                      *
  67.  *      REWIND:         If a file is open it is rewound.                *
  68.  *                                                                      *
  69.  ************************************************************************
  70.  */
  71.  
  72. /* grid definitions */
  73. static long     n_across, n_down, n_inputs;
  74.  
  75. #define N_ACR_MIN       1
  76. #define N_ACR_MAX       16
  77. #define N_ACC_DEF       6
  78. #define N_DWN_MIN       1
  79. #define N_DWN_MAX       16
  80. #define N_DWN_DEF       8
  81.  
  82. /* window coordinates - initialized in usrIO( ) */
  83. static int      wxstrt[4], wystrt[4], wxend[4], wyend[4];
  84.  
  85. typedef struct _grid {
  86.         unsigned char   gr_key;         /* window key for grid */
  87.         unsigned char   gr_flag;        /* grid flag */
  88.         int      gr_xoff, gr_yoff;      /* x,y offset from window origin */
  89.         int      gr_nx, gr_ny;          /* # pixels in x, y directions */
  90.         int      gr_pxx, gr_pxy;        /* size of a grid pixel */
  91.         int      gr_color[3];           /* color of lines and pixels */
  92. #define          GR_OFF         0       /* off color index */
  93. #define          GR_ON          1       /* on color index */
  94. #define          GR_LINE        2       /* line color index */
  95.         float   *gr_data;               /* data for grid */
  96. } GRID;
  97.  
  98. static  GRID    ip_grid = { 0 };        /* Input Grid */
  99. static  GRID    f1_grid = { 0 };        /* F1 grid (ART 1) */
  100. static  float   f1data[ N_ACR_MAX * N_DWN_MAX ]; /* f1 data */
  101. static  char    ip_text[] = "Input Pattern";
  102. static  char    f1_text[] = "F1 Activity";
  103. static  int     wrstepf =  0 ;  /* WRSTEP flag */
  104.  
  105. /* Local menu definitions */
  106.  
  107. #define CR_SCROLL       0
  108. #define CR_SEEK         1
  109. #define CR_ENTER        2
  110. #define CR_QUIT         3
  111. #define CR_AUTO         4
  112.  
  113. #define NULL_STR    0
  114.  
  115. static GMENU_ITEM  PMenuList[] = {      /* Menu list */
  116.           { CR_SCROLL, NULL_STR, NULL_STR },
  117.           { CR_SEEK,   NULL_STR, NULL_STR },
  118.           { CR_ENTER,  NULL_STR, NULL_STR },
  119.           { CR_QUIT,   NULL_STR, NULL_STR },
  120.           { CR_AUTO,   NULL_STR, NULL_STR }
  121. };
  122. static GMENU    AIOMenu  = {    /* Attention I/O menu */
  123.         0,
  124.         4,                              /* # items */
  125.         3,                              /* key */
  126.         0x0000
  127. };
  128. static GMENU    LrnMenu  = {    /* Attention I/O menu */
  129.         0,
  130.         5,                              /* # items */
  131.         3,                              /* key */
  132.         0x0000
  133. };
  134.  
  135. /* File definitions */
  136. static  char    filename[13];
  137. static  char    filenroot[9] = "art1";          /* Default .nna file */
  138. static  int     curr_pattern, n_patterns;   /* pattern index, # patterns */
  139. #define MAX_N_PATTERNS  100
  140. static  long    filepos[ MAX_N_PATTERNS ];      /* Array of file positions */
  141. static  int     shuffle_array[ MAX_N_PATTERNS ];/* Index into shuffle array */
  142. static  int     shufflex =  0 ;         /* Shuffle Index */
  143. #define MAX_STR 78                              /* For reading from file */
  144. static  char    fbuf[MAX_STR + 1];              /* buffer for file i/o */
  145. static  FILE    *fp = 0;                        /* File pointer */
  146. static  float   fdata[ N_ACR_MAX * N_DWN_MAX ]; /* file data */
  147. static  float   fout[7];                        /* file desired output */
  148.  
  149. /* Network parameters */
  150. static  int   nlayp, ninp, noutp, ltype;        /* Network parameters */
  151. static  char  *csp, *netnp;                     /* Network pointers*/
  152.  
  153. /* Graphics parameters */
  154. static  int   xsize, ysize, ncolor, chrx, chry; /* graphics parameters */
  155. /* Miscellaneous */
  156. static  int     abortio;
  157. static  int     autoip;
  158.  
  159. #ifdef DLC
  160. /* --- prototypes --- */
  161.         DispGrid( GRID * );
  162.         DispPattern( GRID * );
  163.         Sketch( GRID * );
  164.         DrawPixel( GRID *, int, int, int );
  165.         FillPosArr(  );
  166.         ReadFData( );
  167.         WriteFData( );
  168.         Shuffle( int );
  169. #endif
  170.  
  171. DispGrid( gridp )
  172. GRID    *gridp;         /* pointer to grid structure */
  173. {
  174.   int   wx;             /* work index */
  175.   int   x0,y0,x1,y1;    /* endpoints of gridlines */
  176.  
  177.   /* Draw vertical gridlines */
  178.   x1 = x0 = gridp->gr_xoff;
  179.   y0 = gridp->gr_yoff;
  180.   y1 = y0 + gridp->gr_ny * ( gridp->gr_pxy + 1 );
  181.  
  182.   for (wx = 0; wx <= gridp->gr_nx; wx++, x1 = x0 += gridp->gr_pxx + 1 )
  183.     ug_line( gridp->gr_key, gridp->gr_color[GR_LINE], 0, x0, y0, x1, y1, 0 );
  184.  
  185.   /* Draw horizontal gridlines */
  186.   x0 = gridp->gr_xoff;
  187.   x1 = x0 + gridp->gr_nx * ( gridp->gr_pxx + 1 );
  188.   y1 = y0 = gridp->gr_yoff;
  189.  
  190.   for (wx = 0; wx <= gridp->gr_ny; wx++, y1 = y0 += gridp->gr_pxy + 1 )
  191.     ug_line( gridp->gr_key, gridp->gr_color[GR_LINE], 0, x0, y0, x1, y1, 0 );
  192. }
  193.  
  194. VOID DispPattern( gridp )
  195. GRID    *gridp;         /* Pointer to grid structure */
  196. {
  197.   int   wx, wy, wz;     /* work indices */
  198.   float *dp;            /* pointer to data */
  199.  
  200.   dp = &gridp->gr_data[0];
  201.   if ( dp == ( float * )0 ) return;
  202.  
  203.   for ( wy = gridp->gr_ny, wz = 0; --wy >= 0 ; )
  204.     for ( wx = 0; wx < gridp->gr_nx; wx++, wz++ )
  205.       DrawPixel( gridp, wx, wy,
  206.                  gridp->gr_color[ dp[wz]>0.0001 ? GR_ON : GR_OFF ] );
  207. }
  208.  
  209.  
  210. VOID Sketch( gridp )
  211. GRID    *gridp;         /* Pointer to grid structure */
  212. {
  213.   int   x0, y0, x1, y1;         /* Grid boundary */
  214.   int   wx, wy, wz;             /* work indices */
  215.   int   key, xp, yp, button;    /* mouse parameters */
  216.   float *dp;                    /* pointer to data */
  217.  
  218.   dp = &gridp->gr_data[0];
  219.   if ( dp == ( float * )0 ) return;
  220.   x0 = gridp->gr_xoff;
  221.   y0 = gridp->gr_yoff;
  222.   x1 = x0 + gridp->gr_nx * ( gridp->gr_pxx + 1 );
  223.   y1 = y0 + gridp->gr_ny * ( gridp->gr_pxy + 1 );
  224.  
  225.   for (;;) {
  226.     ug_mouse( &key, &xp, &yp, &button );
  227.     if ( key != gridp->gr_key || xp < x0 || xp >= x1 || yp < y0 || yp >= y1 )
  228.       return;
  229.     if ( button == MBUT_LEFT || button == MBUT_RIGHT ) {
  230.       /* Calculate grid coordinate */
  231.       wx = ( xp - x0 ) / ( gridp->gr_pxx + 1 );
  232.       wy = ( yp - y0 ) / ( gridp->gr_pxy + 1 );
  233.       DrawPixel( gridp, wx, wy,
  234.                  gridp->gr_color[ button == MBUT_LEFT ? GR_ON : GR_OFF ] );
  235.       /* Modify data array */
  236.       wz = (gridp->gr_ny - wy - 1) * gridp->gr_nx + wx;
  237.       dp[wz] = button == MBUT_LEFT ? 1.0 : -1.0;
  238.     }
  239.   }
  240. }
  241.  
  242.  
  243. DrawPixel( gridp, x, y, color )
  244. GRID    *gridp;         /* pointer to grid structure */
  245. int      x, y;          /* grid coordinate */
  246. int      color;         /* pixel color */
  247. {
  248.       int       xstrt, ystrt;
  249.  
  250.       xstrt = gridp->gr_xoff + 1 + ( gridp->gr_pxx + 1 ) * x;
  251.       ystrt = gridp->gr_yoff + 1 + ( gridp->gr_pxy + 1 ) * y;
  252.       ug_boxf( gridp->gr_key, color, 0, xstrt, ystrt,
  253.                xstrt + gridp->gr_pxx - 1, ystrt + gridp->gr_pxy - 1 );
  254. }
  255.  
  256. /* NOTE: following routine will not cope with
  257.    general format ".nna" files. In particular, it
  258.    is assumed that any new line which does not
  259.    start with a continuation character ('&') or
  260.    a comment character ('!') is the start of a
  261.    non-empty record; it is also assumed that there
  262.    are no comments in the middle of records */
  263.  
  264. FillPosArr( )
  265. {
  266.   int   wx;             /* work index */
  267.   int   ch;             /* Character */
  268.   long  fpos;           /* File position */
  269.   int   ftt;            /* First time through */
  270.  
  271.   fseek( fp, 0l, 0 );                   /* beginning of file */
  272.   for ( wx = 0; wx < MAX_N_PATTERNS; ) {
  273.     if ( (ch=fgetc( fp )) != '!' && ch != '&' ) {
  274.       ungetc( ch, fp );
  275.       fpos = ftell( fp );
  276.       ftt = 1;
  277.     } else ftt = 0;
  278.     /* Make sure there is something on the line;
  279.        scan to end of line */
  280.    while ( (ch=fgetc( fp)) != NEW_LINE ) {
  281.       if ( ftt && ch >= (int)'0' ) {
  282.         filepos[wx++] = fpos;
  283.         ftt = 0;
  284.       }
  285.       if ( ch == EOF ) return( wx );
  286.     }
  287.   }
  288. }
  289.  
  290. ReadFData( flag )
  291. int     flag;           /* Whether or not desired output should be read */
  292. {
  293.   int    wx, wy;        /* work index */
  294.   int    ch;
  295.   float *dp;            /* data pointer */
  296.  
  297.   char  sbuf[100];
  298.  
  299.   if ( curr_pattern < 0 ) curr_pattern = 0;
  300.  
  301.   if ( curr_pattern >= n_patterns ) {   /* Don't read from file */
  302.     for ( wx = 0; wx < n_inputs; wx++ )
  303.       fdata[wx] = -1.0;
  304.     curr_pattern = n_patterns;
  305.     return( 0 );
  306.   } else {
  307.     fseek( fp, filepos[curr_pattern], 0 );
  308.     /* NOTE: Following code assumes data has been written using
  309.        format of WriteFData( ) routine */
  310.     for (wx = 0, wy = 18, dp = fdata; wx < n_inputs;
  311.          wx++, wy--, dp++ ) {
  312.       if ( wy == 0 ) {  /* Look for continuation */
  313.         while ( (ch=fgetc( fp)) != NEW_LINE )
  314.           if ( ch == EOF ) goto bad_return;
  315.         if ( fgetc( fp ) != '&' ) goto bad_return;
  316.         wy = 18;
  317.       }
  318.       if ( fscanf( fp, "%f", dp ) <= 0 ) goto bad_return;
  319.     }
  320.   }
  321.     fseek( fp, filepos[curr_pattern], 0 );
  322.   return( 0 );
  323.  
  324. bad_return:
  325.   PutStr( "Bad file format\n" );
  326.   return( -1 );
  327. }
  328.  
  329.  
  330. WriteFData( flag )
  331. int     flag;           /* Whether or not desired output should be written */
  332. {
  333.   int   wx, wy;         /* work index */
  334.  
  335.   if ( curr_pattern < 0 ) curr_pattern = 0;
  336.  
  337.   if ( curr_pattern >= n_patterns ) {
  338.     curr_pattern = n_patterns;
  339.     n_patterns++;
  340.     fseek( fp, 0l, 2 );                 /* Seek End of File */
  341.     filepos[curr_pattern] = ftell( fp );
  342.   }
  343.  
  344.   fseek( fp, filepos[curr_pattern], 0 );
  345.  
  346.   fputc( ' ', fp );
  347.   for ( wx = 0, wy = 18; wx < n_inputs; wx++, wy-- )
  348.   {
  349.     if ( wy == 0 ) {
  350.       fputc( NEW_LINE, fp );
  351.       fputc( '&' , fp );                /* Continuation line */
  352.       wy = 18;
  353.     }
  354.     fprintf( fp, " %2.0f.", fdata[wx] );
  355.   }
  356.   fputc( NEW_LINE, fp );
  357.   curr_pattern++;
  358. }
  359.  
  360.  
  361. Shuffle( size )
  362. int     size;
  363. {
  364.   int   wx, wy, wz;
  365.   int   swap;
  366.  
  367.   for ( wx = 0, wy = size; wx < size; wx++, wy-- ) {
  368.     wz = rand( ) % wy;
  369.     swap = shuffle_array[wx];
  370.     shuffle_array[wx] = shuffle_array[wx + wz];
  371.     shuffle_array[wx + wz] = swap;
  372.   }
  373. }
  374.  
  375. /*****************************************************************************/
  376. /*                                                                           */
  377. /* Functions necessary for handling the User I/O package itself.             */
  378. /*                                                                           */
  379. /*****************************************************************************/
  380.  
  381. /* */
  382. /* UIO_Init   function to initialize user I/O
  383.  ************************************************************************
  384. */
  385. NINT UIO_Init(file)
  386. TEXT *file;
  387. {
  388.   NINT ret_val = UIO_OK;
  389.  
  390.     fp = (FILE *)0;
  391.  
  392.     PMenuList[CR_SCROLL].text = "Scroll";
  393.     PMenuList[CR_SCROLL].text2 = "";
  394.  
  395.     PMenuList[CR_SEEK].text = "Seek";
  396.     PMenuList[CR_SEEK].text2 = "";
  397.  
  398.     PMenuList[CR_ENTER].text = "Enter";
  399.     PMenuList[CR_ENTER].text2 = "";
  400.  
  401.     PMenuList[CR_QUIT].text = "Quit";
  402.     PMenuList[CR_QUIT].text2 = "";
  403.  
  404.     PMenuList[CR_AUTO].text = "Auto";
  405.     PMenuList[CR_AUTO].text2 = "";
  406.  
  407.     AIOMenu.item = PMenuList;
  408.     LrnMenu.item = PMenuList;
  409.  
  410.         /* Get screen parameters */
  411.         ug_gparms( &xsize, &ysize, &ncolor, &chrx, &chry);
  412.  
  413.         if ( ncolor < 8 ) {
  414.           gm_intcolor = 1;
  415.           gm_txtcolor = 0;
  416.           gm_outcolor = 0;
  417.         } else {
  418.           gm_intcolor = 7;
  419.           gm_txtcolor = 4;
  420.           gm_outcolor = 0;
  421.         }
  422.         ip_grid.gr_color[GR_OFF]  = f1_grid.gr_color[GR_OFF]  = gm_intcolor;
  423.         ip_grid.gr_color[GR_ON]   = f1_grid.gr_color[GR_ON]   = gm_txtcolor;
  424.         ip_grid.gr_color[GR_LINE] = f1_grid.gr_color[GR_LINE] = gm_txtcolor;
  425.  
  426.         InitGMenu( &AIOMenu, chrx, chry );
  427.         AIOMenu.x0 = 0; /* Menu position relative to window */
  428.         AIOMenu.y0 = 0;
  429.  
  430.         InitGMenu( &LrnMenu, chrx, chry );
  431.         LrnMenu.x0 = 0; /* Menu position relative to window */
  432.         LrnMenu.y0 = 0;
  433.  
  434.   return(ret_val);
  435. }
  436.  
  437. /* */
  438. /* UIO_Term   function to terminate user I/O
  439.  ************************************************************************
  440. */
  441. NINT UIO_Term(process)
  442. NINT process;
  443. {
  444.   NINT ret_val = UIO_OK;
  445.  
  446.             /* if a file is open */
  447.         if ( fp != (FILE *)0 ) fclose( fp );  /* close it */
  448.         fp = (FILE *)0;
  449.         PutStr( "bye bye\n" );      /* display a message */
  450.  
  451.   return(ret_val);
  452. }
  453.  
  454. /* */
  455. /* UIO_Attention  function to signal user I/O program
  456.  ************************************************************************
  457. */
  458. NINT UIO_Attention()
  459. {
  460.     NINT ret_val = UIO_OK;
  461.     NINT newfile;
  462.     NINT key, xp, yp, button;                  /* mouse interface */
  463.  
  464.     TEXT sbuf[60], *sp;                        /* work string and pointer */
  465.  
  466.     GMENU_ITEM  *gmip;
  467.  
  468.       if ( fp != (FILE *) 0 ) fclose( fp );
  469.  
  470.       sprintf( sbuf,
  471.                "Enter name of pattern file ( default: %s ):", filenroot );
  472.       PutStr( sbuf );
  473.       sp = GetStr( );
  474.       PutStr("\n");
  475.       if ( strcmp( sp, "" ) != 0 ) strncpy( filenroot, sp, 9 );
  476.       strcpy( filename, filenroot );
  477.       strcat( filename, ".nna" );
  478.       if ( (fp = fopen( filename, "r" )) == (FILE *)0 )
  479.         {
  480.           newfile = 1;
  481.         }
  482.       else
  483.         {
  484.           newfile = 0;
  485.           fclose(fp);
  486.         }
  487.  
  488.       if ( ( fp = fopen( filename, "a+" ) ) == (FILE *)0 ) {
  489.         sprintf( sbuf, "Cannot open file <%s>\n", filename );
  490.         PutStr( sbuf );
  491.         goto aio_return;
  492.       }
  493.  
  494.       fseek( fp, 0l, 0 );
  495.       if ( newfile ) {                  /* New file */
  496.         PutStr( "Enter number of pixels across:" );
  497.         sp = GetStr( );
  498.         PutStr("\n");
  499.         sscanf( sp, "%ld", &n_across );
  500.         if ( n_across < N_ACR_MIN ) n_across = N_ACR_MIN;
  501.         if ( n_across > N_ACR_MAX ) n_across = N_ACR_MAX;
  502.         PutStr( "Enter number of pixels down:" );
  503.         sp = GetStr( );
  504.         PutStr("\n");
  505.         sscanf( sp, "%ld", &n_down );
  506.         if ( n_down < N_DWN_MIN ) n_down = N_DWN_MIN;
  507.         if ( n_down > N_DWN_MAX ) n_down = N_DWN_MAX;
  508.         fprintf( fp,
  509.         "! number of pixels across = %2ld, number of pixels down = %2ld%s",
  510.                  n_across, n_down, NEW_LINE_STR );
  511.       } else {
  512.         if ( fgets( fbuf, MAX_STR, fp ) == 0 ) goto aio_read_error;
  513.         sscanf( fbuf,
  514.         "! number of pixels across = %ld, number of pixels down = %ld",
  515.                  &n_across, &n_down );
  516.  
  517.         if ( n_across < N_ACR_MIN || n_across > N_ACR_MAX ||
  518.              n_down   < N_DWN_MIN || n_down   > N_DWN_MAX ) {
  519.           PutStr( "Unexpected values in file\n" );
  520.           goto aio_return;
  521.         }
  522.       }
  523.       n_inputs = n_across * n_down;     /* # PEs in input buffer */
  524.  
  525.      n_patterns = FillPosArr(  ); /* Fill Position array */
  526.      curr_pattern = n_patterns;  /* End of file */
  527.       ReadFData( 0 );                   /* Special eof case */
  528.  
  529.  
  530.       /* Set up grid window and grid */
  531.       ip_grid.gr_data = fdata;
  532.       ip_grid.gr_key = 1;
  533.       ip_grid.gr_flag = 0;
  534.       ip_grid.gr_xoff = ip_grid.gr_yoff = 0;
  535.       ip_grid.gr_nx = n_across;
  536.       ip_grid.gr_ny = n_down;
  537.       ip_grid.gr_pxx = 16 - ( n_across + n_down ) / 4;
  538.       ip_grid.gr_pxy = ip_grid.gr_pxx;
  539.  
  540.       wxstrt[0] = ( xsize - (ip_grid.gr_nx * (ip_grid.gr_pxx+1) + 1) ) / 2 ;
  541.       wystrt[0] = ( ysize - (ip_grid.gr_ny * (ip_grid.gr_pxy+1) + 1) ) / 2 ;
  542.       wxend[0] = wxstrt[0] + ip_grid.gr_nx * (ip_grid.gr_pxx+1);
  543.       wyend[0] = wystrt[0] + ip_grid.gr_ny * (ip_grid.gr_pxy+1);
  544.       ug_window( ip_grid.gr_key, ip_grid.gr_color[GR_OFF],
  545.                  wxstrt[0], wystrt[0], wxend[0], wyend[0] );
  546.       DispGrid( &ip_grid );
  547.       DispPattern( &ip_grid );
  548.  
  549.       /* Set up menu and menu window */
  550.       AIOMenu.key = 2;
  551.       wxstrt[1] = ( xsize - AIOMenu.x1 ) / 2;
  552.       wxend[1] = wxstrt[1] + AIOMenu.x1 + 2;
  553.       wystrt[1] = ( wystrt[0] - AIOMenu.y1 ) / 2;
  554.       wyend[1] = wystrt[1] + AIOMenu.y1 + 2;
  555.       ug_window( AIOMenu.key, ip_grid.gr_color[GR_OFF],
  556.                  wxstrt[1], wystrt[1], wxend[1], wyend[1] );
  557.       DispGMenu( &AIOMenu );
  558.  
  559.       for ( ; ; ) {
  560.         while ( ( gmip=LookGMenu(&AIOMenu,&button) ) != (GMENU_ITEM *) 0 ) {
  561.           switch( gmip->code ) {
  562.             case CR_SCROLL:
  563.               if ( button == MBUT_LEFT )  {             /* Scroll down */
  564.                 curr_pattern++;
  565.                 if ( ReadFData( 0 ) < 0 ) goto aio_return;
  566.                 DispPattern( &ip_grid );
  567.               }
  568.               if ( button == MBUT_RIGHT ) {             /* Scroll up */
  569.                 curr_pattern--;
  570.                 if ( ReadFData( 0 ) < 0 ) goto aio_return;
  571.                 DispPattern( &ip_grid );
  572.               }
  573.               break;
  574.             case CR_SEEK:
  575.               if ( button == MBUT_LEFT ) {      /* Start of file data */
  576.                 curr_pattern = 0;
  577.                 if ( ReadFData( 0 ) < 0 ) goto aio_return;
  578.                 DispPattern( &ip_grid );
  579.               }
  580.               if ( button == MBUT_RIGHT ) {             /* End of file data */
  581.                 curr_pattern = n_patterns;
  582.                 if ( ReadFData( 0 ) < 0 ) goto aio_return;
  583.                 DispPattern( &ip_grid );
  584.               }
  585.               break;
  586.             case CR_ENTER:
  587.               if ( button == MBUT_LEFT || button == MBUT_RIGHT ) {
  588.                 WriteFData( 0 );
  589.                 ReadFData( 0 );
  590.                 DispPattern( &ip_grid );
  591.               }
  592.               break;
  593.             case CR_QUIT:
  594.               if ( button == MBUT_LEFT || button == MBUT_RIGHT ) {
  595.     ret_val = UIO_ERROR;
  596.                 goto aio_return;
  597.               }
  598.               break;
  599.           }
  600.  
  601.           /* If button was pressed, wait for it to be released */
  602.           while ( button != 0 )
  603.             ug_mouse( &key, &xp, &yp, &button );
  604.         }
  605.         Sketch( &ip_grid );
  606.       }
  607.  
  608. aio_read_error:
  609.       sprintf( sbuf, "Error reading file <%s>\n", filename );
  610.       PutStr( sbuf );
  611.  
  612. aio_return:
  613.       if ( fp != (FILE *)0 ) fclose( fp );
  614.       fp = (FILE *)0;
  615.       ug_windel( 1 );
  616.       ug_windel( 2 );
  617.  
  618.       return(ret_val);
  619. }
  620.  
  621. /* */
  622. /*****************************************************************************/
  623. /*                                                                           */
  624. /*  Functions necessary for handling a learning session.                     */
  625. /*                                                                           */
  626. /*****************************************************************************/
  627.  
  628. /* UIO_Learn_Start  function to initiate learning
  629.  ************************************************************************
  630. */
  631. NINT UIO_Learn_Start()
  632. {
  633.     NINT ret_val = UIO_OK;
  634.     NINT wx, wy;                               /* work indices */
  635.     TEXT sbuf[60], *sp;                        /* work string and pointer */
  636.  
  637.       abortio = 0;                              /* abort flag */
  638.       autoip = 0;                               /* Assume hand input */
  639.       wrstepf = 0;                              /* write step flag */
  640.       if ( fp == (FILE *)0 ) {                  /* Not yet opened */
  641.         sprintf( sbuf,
  642.                  "Enter name of pattern file ( default: %s ):", filenroot );
  643.         PutStr( sbuf );
  644.         sp = GetStr( );
  645.         PutStr("\n");
  646.         if ( strcmp( sp, "" ) != 0 ) strncpy( filenroot, sp, 9 );
  647.         strcpy( filename, filenroot );
  648.         strcat( filename, ".nna" );
  649.         if ( ( fp = fopen( filename, "r" ) ) == (FILE *)0 ) {
  650.           sprintf( sbuf, "Cannot open file <%s>; learn aborted\n", filename );
  651.           PutStr( sbuf );
  652.           abortio = 1;
  653.           goto lrns_return;
  654.         }
  655.         shufflex = 0;
  656.         /* Initialize shuffle array */
  657.         for ( wx = 0; wx < MAX_N_PATTERNS; wx++ )
  658.           shuffle_array[ wx ] = wx;
  659.  
  660.         n_patterns = FillPosArr(  );            /* Fill Position array */
  661.         curr_pattern = 0;                       /* Start of of file */
  662.       }
  663.  
  664.       fseek( fp, 0l, 0 );                       /* rewind */
  665.  
  666.       if ( fgets( fbuf, MAX_STR, fp ) == 0 ) {
  667.         PutStr( "Read error; learn aborted\n" );
  668.         abortio = 1;
  669.         goto lrns_return;
  670.       }
  671.       sscanf( fbuf,
  672.         "! number of pixels across = %ld, number of pixels down = %ld",
  673.                  &n_across, &n_down );
  674.       if ( n_across < N_ACR_MIN || n_across > N_ACR_MAX ||
  675.            n_down   < N_DWN_MIN || n_down   > N_DWN_MAX ) {
  676.         PutStr( "Unexpected values in file; learn aborted\n" );
  677.         abortio = 1;
  678.         goto lrns_return;
  679.       }
  680.  
  681.       n_inputs = n_across * n_down;     /* # PEs in input buffer */
  682.       ug_rdnetinf( &nlayp, &ninp, &noutp, <ype, &csp, &netnp );
  683.      if ( n_inputs != ninp ) {
  684.         PutStr( "Data incompatible with network; learn aborted\n" );
  685.         abortio = 1;
  686.         goto lrns_return;
  687.       }
  688.  
  689.       /* Initialize grids and associated window */
  690.       ip_grid.gr_data = fdata;
  691.       f1_grid.gr_data = f1data;
  692.       ip_grid.gr_key = f1_grid.gr_key = 1;
  693.       ip_grid.gr_flag = f1_grid.gr_flag = 0;
  694.       ip_grid.gr_nx = f1_grid.gr_nx = n_across;
  695.       ip_grid.gr_ny = f1_grid.gr_ny =n_down;
  696.       ip_grid.gr_pxx = f1_grid.gr_pxx = 16 - ( n_across / 2 );
  697.       ip_grid.gr_pxy = f1_grid.gr_pxy = ip_grid.gr_pxx;
  698.       ip_grid.gr_xoff = 3 * chrx;
  699.       ip_grid.gr_yoff = f1_grid.gr_yoff = 4 * chry;
  700.       f1_grid.gr_xoff = ip_grid.gr_xoff + 22 * chrx;
  701.  
  702.       wx = 50 * chrx;
  703.       wy = 5 * chry + ip_grid.gr_ny * ( ip_grid.gr_pxy + 1 ) + 1;
  704.       wxstrt[0] = ( xsize - wx ) / 2 ;
  705.       wystrt[0] = ( ysize - wy ) / 2 ;
  706.       wxend[0] = wxstrt[0] + wx;
  707.       wyend[0] = wystrt[0] + wy;
  708.  
  709.       ug_window( ip_grid.gr_key, ip_grid.gr_color[GR_OFF],
  710.                  wxstrt[0], wystrt[0], wxend[0], wyend[0] );
  711.  
  712.       /* Set up menu and menu window */
  713.       LrnMenu.key = 2;
  714.       wxstrt[1] = ( xsize - LrnMenu.x1 ) / 2;
  715.       wxend[1] = wxstrt[1] + LrnMenu.x1 + 2;
  716.       wystrt[1] = ( wystrt[0] - LrnMenu.y1 ) / 2;
  717.       wyend[1] = wystrt[1] + LrnMenu.y1 + 2;
  718.       ug_window( LrnMenu.key, gm_intcolor,
  719.                  wxstrt[1], wystrt[1], wxend[1], wyend[1] );
  720.  
  721. lrns_return:
  722.       if ( abortio ) {
  723.         if ( fp != (FILE *)0 ) fclose( fp );
  724.         fp = (FILE *)0;
  725.         ug_windel( 1 );
  726.         ug_windel( 2 );
  727.   ret_val = UIO_ERROR;
  728.       }
  729.  
  730.       return(ret_val);
  731. }
  732.  
  733. /* */
  734. /* UIO_Learn_Input  function to read training data
  735.  ************************************************************************
  736. */
  737. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  738. NINT  LayN;
  739. NINT  nPEs;
  740. SREAL *Datap;
  741. {
  742.     NINT ret_val = UIO_OK;
  743.     NINT key, xp, yp, button;                  /* mouse interface */
  744.     TEXT sbuf[60], *sp;                        /* work string and pointer */
  745.     GMENU_ITEM  *gmip;
  746.  
  747.  
  748.      if ( abortio ) goto lrnin_return;
  749.       /* Display grids */
  750.       if ( ReadFData( 0 ) < 0 ) goto lrnin_return;
  751.       ug_winclr( ip_grid.gr_key );
  752.       DispGrid( &ip_grid );
  753.       DispGrid( &f1_grid );
  754.       ug_puts( ip_grid.gr_key, ip_grid.gr_color[GR_ON], 0,
  755.                3 * chrx, 3 * chry, ip_text, 0 );
  756.       ug_puts( ip_grid.gr_key, ip_grid.gr_color[GR_ON], 0,
  757.                25 * chrx, 3 * chry, f1_text, 0 );
  758.       if ( !autoip ) {
  759.         ug_winclr( LrnMenu.key );
  760.         DispGMenu( &LrnMenu );
  761.         DispPattern( &ip_grid );
  762.         for ( ; ; ) {
  763.           while ( ( gmip=LookGMenu(&LrnMenu,&button) ) != (GMENU_ITEM *) 0 ) {
  764.             switch( gmip->code ) {
  765.               case CR_SCROLL:
  766.                 if ( button == MBUT_LEFT )  {           /* Scroll down */
  767.                   curr_pattern++;
  768.                   if ( ReadFData( 0 ) < 0 ) goto lrnin_return;
  769.                   DispPattern( &ip_grid );
  770.                 }
  771.                 if ( button == MBUT_RIGHT ) {           /* Scroll up */
  772.                   curr_pattern--;
  773.                   if ( ReadFData( 0 ) < 0 ) goto lrnin_return;
  774.                   DispPattern( &ip_grid );
  775.                 }
  776.                 break;
  777.               case CR_SEEK:
  778.                 if ( button == MBUT_LEFT ) {    /* Start of file data */
  779.                   curr_pattern = 0;
  780.                   if ( ReadFData( 0 ) < 0 ) goto lrnin_return;
  781.                   DispPattern( &ip_grid );
  782.                 }
  783.                 if ( button == MBUT_RIGHT ) {           /* End of file data */
  784.                   curr_pattern = n_patterns;
  785.                   if ( ReadFData( 0 ) < 0 ) goto lrnin_return;
  786.                   DispPattern( &ip_grid );
  787.                 }
  788.                 break;
  789.  
  790.               case CR_ENTER:
  791.                 if ( button == MBUT_LEFT || button == MBUT_RIGHT ) {
  792. /* added size_t cast on 3rd memcpy() arg for MS-C 7.0; 4-28-93 mjs */
  793. #ifdef MSC
  794.                   memcpy( Datap, fdata, (size_t)(n_inputs * sizeof( float )) );
  795. #else
  796.                   memcpy( Datap,
  797.         fdata, n_inputs * sizeof( float ) );
  798. #endif
  799.                   curr_pattern++;
  800.                   goto lrnin_return;
  801.                 }
  802.                 break;
  803.               case CR_QUIT:
  804.                 if ( button == MBUT_LEFT || button == MBUT_RIGHT ) {
  805.      ret_val = UIO_ERROR;
  806.                   goto lrnin_return;
  807.                 }
  808.                 break;
  809.               case CR_AUTO:
  810.                 if ( button == MBUT_LEFT || button == MBUT_RIGHT ) {
  811.                   autoip = 1;
  812.                   goto auto_lrn;
  813.                 }
  814.                 break;
  815.             }
  816.             /* If button was pressed, wait for it to be released */
  817.             while ( button != 0 )
  818.               ug_mouse( &key, &xp, &yp, &button );
  819.           }
  820.           Sketch( &ip_grid );
  821.         }
  822.       } else {
  823. auto_lrn:
  824.         if ( shufflex == 0 ) Shuffle( n_patterns );
  825.         curr_pattern = shuffle_array[ shufflex++ ];
  826.         if ( ReadFData( 0 ) < 0 ) {
  827.           PutStr( "Error reading file; learn aborted\n" );
  828.           abortio = 1;
  829.           goto lrnin_return;
  830.         }
  831.         if ( shufflex >= n_patterns ) shufflex = 0;
  832. /* added size_t cast on 3rd memcpy() arg for MS-C 7.0; 4-28-93 mjs */
  833. #ifdef MSC
  834.         memcpy( Datap, fdata, (size_t)(n_inputs * sizeof( float )) );
  835. #else
  836.         memcpy( Datap,
  837.     fdata, n_inputs * sizeof( float ) );
  838. #endif
  839.      }
  840.  
  841. lrnin_return:
  842.       if ( abortio ) {
  843.         if ( fp != (FILE *)0 ) fclose( fp );
  844.         fp = (FILE *)0;
  845.         ug_windel( 1 );
  846.         ug_windel( 2 );
  847.   ret_val = UIO_ERROR;
  848.       }
  849.  
  850.       return(ret_val);
  851. }
  852.  
  853.  
  854. /* FUNCTION */
  855. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  856. NINT  LayN;
  857. NINT  nPEs;
  858. SREAL *Datap;
  859. {
  860.   NINT ret_val = UIO_OK;
  861.  
  862.   /* USER TO PLACE CODE HERE */
  863.  
  864.         /* IODATA points to an empty array of IOCOUNT values.  The
  865.            elements of the array will become the desired outputs for
  866.            training purposes.  These desired outputs correspond to
  867.            the most recent "RQ_LEARNIN" request.
  868.         */
  869.  
  870.  
  871.   return(ret_val);
  872. }
  873.  
  874. /* */
  875. /* UIO_Learn_Result function to write results from learning
  876.  ************************************************************************
  877. */
  878. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  879. NINT  LayN;
  880. NINT  nPEs;
  881. SREAL *Datap;
  882. {
  883.     NINT ret_val = UIO_OK;
  884.     NINT  key, xp, yp, button;                  /* mouse interface */
  885.  
  886.         if ( abortio ) goto write_return;
  887.         if ( autoip ) {
  888.         } else {
  889.           for ( ; ; ) {
  890.             ug_mouse( &key, &xp, &yp, &button ); /* wait for mouse */
  891.             if (button == MBUT_LEFT || button == MBUT_RIGHT) break;
  892.           }
  893.         }
  894.  
  895. write_return:
  896.       if ( abortio ) {
  897.         if ( fp != (FILE *)0 ) fclose( fp );
  898.         fp = (FILE *)0;
  899.         ug_windel( 1 );
  900.         ug_windel( 2 );
  901.   ret_val = UIO_ERROR;
  902.       }
  903.  
  904.       return(ret_val);
  905. }
  906.  
  907.  
  908. /* FUNCTION */
  909. NINT UIO_Learn_End()
  910. {
  911.   NINT ret_val = UIO_OK;
  912.  
  913.   /* USER TO PLACE CODE HERE */
  914.  
  915.   return(ret_val);
  916. }
  917.  
  918. /* */
  919. /*****************************************************************************/
  920. /*                                                                           */
  921. /*  Functions necessary for handling a recall or testing session.            */
  922. /*                                                                           */
  923. /*****************************************************************************/
  924.  
  925. /* FUNCTION */
  926. NINT UIO_Recall_Start()
  927. {
  928.     NINT ret_val = UIO_OK;
  929.     NINT key, xp, yp, button;                  /* mouse interface */
  930.     NINT wx, wy;                               /* work indices */
  931.     TEXT sbuf[60], *sp;                        /* work string and pointer */
  932.     GMENU_ITEM  *gmip;
  933.  
  934.       abortio = 0;                              /* abort flag */
  935.       autoip = 0;                               /* Assume hand input */
  936.       wrstepf = 0;                              /* write step flag */
  937.       if ( fp == (FILE *)0 ) {                  /* Not yet opened */
  938.         sprintf( sbuf,
  939.                  "Enter name of pattern file ( default: %s ):", filenroot );
  940.         PutStr( sbuf );
  941.         sp = GetStr( );
  942.         PutStr("\n");
  943.         if ( strcmp( sp, "" ) != 0 ) strncpy( filenroot, sp, 9 );
  944.         strcpy( filename, filenroot );
  945.         strcat( filename, ".nna" );
  946.         if ( ( fp = fopen( filename, "r" ) ) == (FILE *)0 ) {
  947.           sprintf( sbuf, "Cannot open file <%s>; learn aborted\n", filename );
  948.           PutStr( sbuf );
  949.           abortio = 1;
  950.           goto lrns_return;
  951.         }
  952.         shufflex = 0;
  953.         /* Initialize shuffle array */
  954.         for ( wx = 0; wx < MAX_N_PATTERNS; wx++ )
  955.           shuffle_array[ wx ] = wx;
  956.  
  957.         n_patterns = FillPosArr(  );            /* Fill Position array */
  958.         curr_pattern = 0;                       /* Start of of file */
  959.       }
  960.  
  961.       fseek( fp, 0l, 0 );                       /* rewind */
  962.  
  963.       if ( fgets( fbuf, MAX_STR, fp ) == 0 ) {
  964.         PutStr( "Read error; learn aborted\n" );
  965.         abortio = 1;
  966.         goto lrns_return;
  967.       }
  968.       sscanf( fbuf,
  969.         "! number of pixels across = %ld, number of pixels down = %ld",
  970.                  &n_across, &n_down );
  971.       if ( n_across < N_ACR_MIN || n_across > N_ACR_MAX ||
  972.            n_down   < N_DWN_MIN || n_down   > N_DWN_MAX ) {
  973.         PutStr( "Unexpected values in file; learn aborted\n" );
  974.         abortio = 1;
  975.         goto lrns_return;
  976.       }
  977.  
  978.       n_inputs = n_across * n_down;     /* # PEs in input buffer */
  979.       ug_rdnetinf( &nlayp, &ninp, &noutp, <ype, &csp, &netnp );
  980.      if ( n_inputs != ninp ) {
  981.         PutStr( "Data incompatible with network; learn aborted\n" );
  982.         abortio = 1;
  983.         goto lrns_return;
  984.       }
  985.  
  986.       /* Initialize grids and associated window */
  987.       ip_grid.gr_data = fdata;
  988.       f1_grid.gr_data = f1data;
  989.       ip_grid.gr_key = f1_grid.gr_key = 1;
  990.       ip_grid.gr_flag = f1_grid.gr_flag = 0;
  991.       ip_grid.gr_nx = f1_grid.gr_nx = n_across;
  992.       ip_grid.gr_ny = f1_grid.gr_ny =n_down;
  993.       ip_grid.gr_pxx = f1_grid.gr_pxx = 16 - ( n_across / 2 );
  994.       ip_grid.gr_pxy = f1_grid.gr_pxy = ip_grid.gr_pxx;
  995.       ip_grid.gr_xoff = 3 * chrx;
  996.       ip_grid.gr_yoff = f1_grid.gr_yoff = 4 * chry;
  997.       f1_grid.gr_xoff = ip_grid.gr_xoff + 22 * chrx;
  998.  
  999.       wx = 50 * chrx;
  1000.       wy = 5 * chry + ip_grid.gr_ny * ( ip_grid.gr_pxy + 1 ) + 1;
  1001.       wxstrt[0] = ( xsize - wx ) / 2 ;
  1002.       wystrt[0] = ( ysize - wy ) / 2 ;
  1003.       wxend[0] = wxstrt[0] + wx;
  1004.       wyend[0] = wystrt[0] + wy;
  1005.  
  1006.       ug_window( ip_grid.gr_key, ip_grid.gr_color[GR_OFF],
  1007.                  wxstrt[0], wystrt[0], wxend[0], wyend[0] );
  1008.  
  1009.       /* Set up menu and menu window */
  1010.       LrnMenu.key = 2;
  1011.       wxstrt[1] = ( xsize - LrnMenu.x1 ) / 2;
  1012.       wxend[1] = wxstrt[1] + LrnMenu.x1 + 2;
  1013.       wystrt[1] = ( wystrt[0] - LrnMenu.y1 ) / 2;
  1014.       wyend[1] = wystrt[1] + LrnMenu.y1 + 2;
  1015.       ug_window( LrnMenu.key, gm_intcolor,
  1016.                  wxstrt[1], wystrt[1], wxend[1], wyend[1] );
  1017.  
  1018. lrns_return:
  1019.       if ( abortio ) {
  1020.         if ( fp != (FILE *)0 ) fclose( fp );
  1021.         fp = (FILE *)0;
  1022.         ug_windel( 1 );
  1023.         ug_windel( 2 );
  1024.         ret_val = UIO_ERROR;
  1025.   }
  1026.       return(ret_val);
  1027. }
  1028.  
  1029.  
  1030. /* FUNCTION */
  1031. NINT UIO_Read(LayN, nPEs, Datap)
  1032. NINT  LayN;
  1033. NINT  nPEs;
  1034. SREAL *Datap;
  1035. {
  1036.     NINT ret_val = UIO_OK;
  1037.     NINT key, xp, yp, button;                  /* mouse interface */
  1038.     GMENU_ITEM  *gmip;
  1039.  
  1040.      if ( abortio ) goto lrnin_return;
  1041.       /* Display grids */
  1042.       if ( ReadFData( 0 ) < 0 ) goto lrnin_return;
  1043.       ug_winclr( ip_grid.gr_key );
  1044.       DispGrid( &ip_grid );
  1045.       DispGrid( &f1_grid );
  1046.       ug_puts( ip_grid.gr_key, ip_grid.gr_color[GR_ON], 0,
  1047.                3 * chrx, 3 * chry, ip_text, 0 );
  1048.       ug_puts( ip_grid.gr_key, ip_grid.gr_color[GR_ON], 0,
  1049.                25 * chrx, 3 * chry, f1_text, 0 );
  1050.       if ( !autoip ) {
  1051.         ug_winclr( LrnMenu.key );
  1052.         DispGMenu( &LrnMenu );
  1053.         DispPattern( &ip_grid );
  1054.         for ( ; ; ) {
  1055.           while ( ( gmip=LookGMenu(&LrnMenu,&button) ) != (GMENU_ITEM *) 0 ) {
  1056.             switch( gmip->code ) {
  1057.               case CR_SCROLL:
  1058.                 if ( button == MBUT_LEFT )  {           /* Scroll down */
  1059.                   curr_pattern++;
  1060.                   if ( ReadFData( 0 ) < 0 ) goto lrnin_return;
  1061.                   DispPattern( &ip_grid );
  1062.                 }
  1063.                 if ( button == MBUT_RIGHT ) {           /* Scroll up */
  1064.                   curr_pattern--;
  1065.                   if ( ReadFData( 0 ) < 0 ) goto lrnin_return;
  1066.                   DispPattern( &ip_grid );
  1067.                 }
  1068.                 break;
  1069.               case CR_SEEK:
  1070.                 if ( button == MBUT_LEFT ) {    /* Start of file data */
  1071.                   curr_pattern = 0;
  1072.                   if ( ReadFData( 0 ) < 0 ) goto lrnin_return;
  1073.                   DispPattern( &ip_grid );
  1074.                 }
  1075.                 if ( button == MBUT_RIGHT ) {           /* End of file data */
  1076.                   curr_pattern = n_patterns;
  1077.                   if ( ReadFData( 0 ) < 0 ) goto lrnin_return;
  1078.                   DispPattern( &ip_grid );
  1079.                 }
  1080.                 break;
  1081.               case CR_ENTER:
  1082.                 if ( button == MBUT_LEFT || button == MBUT_RIGHT ) {
  1083. /* added size_t cast on 3rd memcpy() arg for MS-C 7.0; 4-28-93 mjs */
  1084. #ifdef MSC
  1085.             memcpy( Datap, fdata, (size_t)(n_inputs * sizeof( float )) );
  1086. #else
  1087.             memcpy( Datap,
  1088.         fdata, n_inputs * sizeof( float ) );
  1089. #endif
  1090.                   curr_pattern++;
  1091.                   goto lrnin_return;
  1092.                 }
  1093.                 break;
  1094.               case CR_QUIT:
  1095.                 if ( button == MBUT_LEFT || button == MBUT_RIGHT ) {
  1096.       ret_val = UIO_ERROR;
  1097.                   goto lrnin_return;
  1098.                 }
  1099.                 break;
  1100.               case CR_AUTO:
  1101.                 if ( button == MBUT_LEFT || button == MBUT_RIGHT ) {
  1102.                   autoip = 1;
  1103.                   goto auto_lrn;
  1104.                 }
  1105.                 break;
  1106.             }
  1107.             /* If button was pressed, wait for it to be released */
  1108.             while ( button != 0 )
  1109.               ug_mouse( &key, &xp, &yp, &button );
  1110.           }
  1111.           Sketch( &ip_grid );
  1112.         }
  1113.       } else {
  1114. auto_lrn:
  1115.         if ( shufflex == 0 ) Shuffle( n_patterns );
  1116.         curr_pattern = shuffle_array[ shufflex++ ];
  1117.         if ( ReadFData( 0 ) < 0 ) {
  1118.           PutStr( "Error reading file; learn aborted\n" );
  1119.           abortio = 1;
  1120.           goto lrnin_return;
  1121.         }
  1122.         if ( shufflex >= n_patterns ) shufflex = 0;
  1123. /* added size_t cast on 3rd memcpy() arg for MS-C 7.0; 4-28-93 mjs */
  1124. #ifdef MSC
  1125.         memcpy( Datap, fdata, (size_t)(n_inputs * sizeof( float )) );
  1126. #else
  1127.         memcpy( Datap,
  1128.     fdata, n_inputs * sizeof( float ) );
  1129. #endif
  1130.      }
  1131.  
  1132. lrnin_return:
  1133.       if ( abortio ) {
  1134.         if ( fp != (FILE *)0 ) fclose( fp );
  1135.         fp = (FILE *)0;
  1136.         ug_windel( 1 );
  1137.         ug_windel( 2 );
  1138.   ret_val = UIO_ERROR;
  1139.       }
  1140.  
  1141.       return(ret_val);
  1142. }
  1143.  
  1144. /* */
  1145. /* UIO_Write    function to write out results
  1146.  ************************************************************************
  1147. */
  1148. NINT UIO_Write(LayN, nPEs, Datap)
  1149. NINT  LayN;
  1150. NINT  nPEs;
  1151. SREAL *Datap;
  1152. {
  1153.     NINT ret_val = UIO_OK;
  1154.     NINT key, xp, yp, button;                  /* mouse interface */
  1155.  
  1156.         if ( abortio ) goto write_return;
  1157.         if ( autoip ) {
  1158.         } else {
  1159.           for ( ; ; ) {
  1160.             ug_mouse( &key, &xp, &yp, &button ); /* wait for mouse */
  1161.             if (button == MBUT_LEFT || button == MBUT_RIGHT) break;
  1162.           }
  1163.         }
  1164.  
  1165. write_return:
  1166.       if ( abortio ) {
  1167.         if ( fp != (FILE *)0 ) fclose( fp );
  1168.         fp = (FILE *)0;
  1169.         ug_windel( 1 );
  1170.         ug_windel( 2 );
  1171.   ret_val = UIO_ERROR;
  1172.       }
  1173.  
  1174.       return(ret_val);
  1175. }
  1176.  
  1177. /* */
  1178. /* UIO_Write_Step function to write interim results
  1179.  ************************************************************************
  1180. */
  1181. NINT UIO_Write_Step(LayN, nPEs, Datap)
  1182. NINT  LayN;
  1183. NINT  nPEs;
  1184. SREAL *Datap;
  1185. {
  1186.   NINT ret_val = UIO_OK;
  1187.  
  1188.       /* Alternates between pre-resonant and post-resonant F1 activity */
  1189.  
  1190.       if ( abortio ) goto wrstep_return;
  1191.  
  1192.       if ( wrstepf ) {
  1193. /* added size_t cast on 3rd memcpy() arg for MS-C 7.0; 4-28-93 mjs */
  1194. #ifdef MSC
  1195.         memcpy( f1_grid.gr_data, Datap, (size_t)(n_inputs * sizeof( float )) );
  1196. #else
  1197.         memcpy( f1_grid.gr_data, Datap,
  1198.     n_inputs * sizeof( float ) );
  1199. #endif
  1200.         DispPattern( &f1_grid );
  1201.         wrstepf = 0;
  1202.       } else {
  1203. /* added size_t cast on 3rd memcpy() arg for MS-C 7.0; 4-28-93 mjs */
  1204. #ifdef MSC
  1205.         memcpy( f1_grid.gr_data, Datap, (size_t)(n_inputs * sizeof( float )) );
  1206. #else
  1207.         memcpy( f1_grid.gr_data, Datap,
  1208.     n_inputs * sizeof( float ) );
  1209. #endif
  1210.         DispPattern( &ip_grid );
  1211.         wrstepf = 1;
  1212.       }
  1213.        
  1214. wrstep_return:
  1215.       if ( abortio ) {
  1216.         if ( fp != (FILE *)0 ) fclose( fp );
  1217.         fp = (FILE *)0;
  1218.         ug_windel( 1 );
  1219.         ug_windel( 2 );
  1220.         ret_val = UIO_ERROR;
  1221.       }
  1222.  
  1223.   return(ret_val);
  1224. }
  1225.  
  1226.  
  1227. /* */
  1228. /* UIO_Recall_Test  function to read desired output for recall test
  1229.  ************************************************************************
  1230. */
  1231. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  1232. NINT  LayN;
  1233. NINT  nPEs;
  1234. SREAL *Datap;
  1235. {
  1236.   NINT ret_val = UIO_OK;
  1237.  
  1238.  
  1239.         /* IODATA points to an empty array of IOCOUNT values.  The
  1240.            elements of the array will become the desired outputs for
  1241.            recall purposes.  This request is only made during a
  1242.            Execute Network/Recall Test.
  1243.         */
  1244.  
  1245.   return(ret_val);
  1246. }
  1247.  
  1248. /* */
  1249. /* UIO_Recall_End
  1250.  ************************************************************************
  1251. */
  1252. NINT UIO_Recall_End()
  1253. {
  1254.   NINT ret_val = UIO_OK;
  1255.  
  1256.   /* USER TO PLACE CODE HERE */
  1257.  
  1258.   return(ret_val);
  1259. }
  1260.  
  1261.  
  1262. /* */
  1263. /*****************************************************************************/
  1264. /*                                                                           */
  1265. /*  Other miscelaneous functions.                                            */
  1266. /*                                                                           */
  1267. /*****************************************************************************/
  1268.  
  1269. /* FUNCTION */
  1270. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  1271. NINT  Instrument_id;
  1272. NINT  nDataElems;
  1273. SREAL *DataElemp;
  1274. {
  1275.   NINT ret_val = UIO_OK;
  1276.  
  1277.  
  1278.   /* USER TO PLACE CODE HERE */
  1279.  
  1280.   return(ret_val);
  1281. }
  1282.  
  1283. /* FUNCTION */
  1284. NINT UIO_ObjFunc(eoeflag, DataElemp)
  1285. NINT  eoeflag;
  1286. SREAL *DataElemp;
  1287. {
  1288.   NINT ret_val = UIO_OK;
  1289.  
  1290.   /* USER TO PLACE CODE HERE */
  1291.  
  1292.   return(ret_val);
  1293. }
  1294.  
  1295. /* FUNCTION */
  1296. NINT UIO_Rewind()
  1297. {
  1298.   NINT ret_val = UIO_OK;
  1299.  
  1300.  
  1301.   /* USER TO PLACE CODE HERE */
  1302.  
  1303.       if ( fp != (FILE *)0 ) fseek( fp, 0l, 0 );
  1304.  
  1305.   return(ret_val);
  1306. }
  1307.  
  1308.  
  1309. /* */
  1310. /* FUNCTION */
  1311. NINT UIO_Explain(LayN, nPEs, Datap)
  1312. NINT  LayN;
  1313. NINT  nPEs;
  1314. SREAL *Datap;
  1315. {
  1316.   NINT ret_val = UIO_OK;
  1317.  
  1318.  
  1319.   /* USER TO PLACE CODE HERE */
  1320.  
  1321.   return(ret_val);
  1322. }
  1323.